#include <algorithm>

template <typename Object>
class Vector
{
public:
    explicit Vector(int  SPARE_CAPACITY1, int initSize = 0 ) : theSize{initSize} ///构造函数 重写构造函数 使得SPARE_CAPACITY变化                                    
    {
        objects = new Object[theCapacity];
        SPARE_CAPACITY = SPARE_CAPACITY1;
        theCapacity = initSize + SPARE_CAPACITY;

    }

    Vector(const Vector &rhs) : theSize{rhs.theSize}, ///构造函数：从另一个向量继承
                                theCapacity{rhs.theCapacity}, objects{nullptr}
    {
        objects = new Object[theCapacity];
        for (int k = 0; k < theSize; ++k)
            objects[k] = rhs.objects[k];
    }

    Vector &operator=(const Vector &rhs) ///重载=操作符
    {
        Vector copy = rhs;
        std::swap(*this, copy);
        return *this;
    }

    ~Vector() ///析构函数
    {
        delete[] objects;
    }

    Vector(Vector &&rhs) : theSize{rhs.theSize}, ///移动构造函数
                           theCapacity{rhs.theCapacity}, objects{rhs.objects}
    {
        rhs.objects = nullptr;
        rhs.theSize = 0;
        rhs.theCapacity = 0;
    }

    Vector &operator=(Vector &&rhs)
    {
        std::swap(theSize, rhs.theSize);
        std::swap(theCapacity, rhs.theCapacity);
        std::swap(objects, rhs.objects);

        return *this;
    }

    void resize(int newSize) ///重新设置theSize
    {
        if (newSize > theCapacity)
            reserve(newSize * 2); ///若新的size过大，扩大总容量
        theSize = newSize;
    }

    void reserve(int newCapacity) ///进行容量扩大
    {
        if (newCapacity < theSize)
            return;

        Object *newArray = new Object[newCapacity];
        for (int k = 0; k < theSize; ++k)
            newArray[k] = std::move(objects[k]);

        theCapacity = newCapacity;
        std::swap(objects, newArray);
        delete[] newArray;
    }

    Object &operator[](int index) ///重载[ ] 操作符
    {
        return objects[index];
    }
    const Object &operator[](int index) const
    {
        return objects[index];
    }

    bool empty() const ///查看是否为空向量
    {
        return size() == 0;
    }
    int size() const
    {
        return theSize;
    }                    ///返回size
    int capacity() const ///返回theCapacity
    {
        return theCapacity;
    }

    void push_back(const Object &x) ///填充新的object进入向量
    {
        if (theSize == theCapacity)
            reserve(2 * theCapacity + 1);
        objects[theSize++] = x;
    }

    void push_back(Object &&x)
    {
        if (theSize == theCapacity)
            reserve(2 * theCapacity + 1);
        objects[theSize++] = std::move(x);
    }

    void pop_back() ///减少size
    {
        --theSize;
    }
    const Object &back() const ///返回向量元素
    {
        return objects[theSize - 1];
    }

    typedef Object *iterator;
    typedef const Object *const_iterator;

    iterator begin()
    {
        return &objects[0];
    }
    const_iterator begin() const
    {
        return &objects[0];
    }
    iterator end()
    {
        return &objects[size()];
    }
    const_iterator end() const
    {
        return &objects[size()];
    }

    int SPARE_CAPACITY = 16;

private:
    int theSize;
    int theCapacity;
    Object *objects;
};